home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 7 / Night Owl Shareware (NOPV7)(Night Owl Publisher Inc.)(1992).bin / 038a / bash1_12.arj / BASH1-12.TAR / bash-1.12 / builtins / hash.def < prev    next >
Text File  |  1991-07-09  |  5KB  |  208 lines
  1. This file is hash.def, from which is created hash.c.
  2. It implements the builtin "hash" in Bash.
  3.  
  4. Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. $PRODUCES hash.c
  23.  
  24. $BUILTIN hash
  25. $FUNCTION hash_builtin
  26. $SHORT_DOC hash [-r] [name ...]
  27. For each NAME, the full pathname of the command is determined and
  28. remembered.  The -r option causes the shell to forget all remembered
  29. locations.  If no arguments are given, information about remembered
  30. commands is presented.
  31. $END
  32.  
  33. #include <stdio.h>
  34. #include "../shell.h"
  35. #include "../builtins.h"
  36. #include "../flags.h"
  37. #include "hashcom.h"
  38.  
  39. void remember_filename ();
  40.  
  41. void
  42. initialize_filename_hashing ()
  43. {
  44.   hashed_filenames = make_hash_table (FILENAME_HASH_BUCKETS);
  45. }
  46.  
  47. /* Print statistics on the current state of hashed commands.  If LIST is
  48.    not empty, then rehash (or hash in the first place) the specified
  49.    commands. */
  50. hash_builtin (list)
  51.      WORD_LIST *list;
  52. {
  53.   int expunge_hash_table = 0;
  54.   int any_failed = 0;
  55.  
  56.   if (hashing_disabled)
  57.     {
  58.       builtin_error ("Hashing is disabled");
  59.       return (EXECUTION_FAILURE);
  60.     }
  61.  
  62.   while (list)
  63.     {
  64.       if (strcmp (list->word->word, "-r") == 0)
  65.     {
  66.       expunge_hash_table = 1;
  67.       list = list->next;
  68.     }
  69.       else if (strcmp (list->word->word, "--") == 0)
  70.     {
  71.       list = list->next;
  72.       break;
  73.     }
  74.       else if (*list->word->word == '-')
  75.     {
  76.       bad_option (list->word->word);
  77.       return (EXECUTION_FAILURE);
  78.     }
  79.       else
  80.     break;
  81.     }
  82.  
  83.   /* We want hash -r to be silent, but hash -- to print hashing info.  That
  84.      is the reason for the !expunge_hash_table. */
  85.   if (!list && !expunge_hash_table)
  86.     {
  87.       /* Print information about current hashed info. */
  88.       int any_printed = 0;
  89.       int bucket = 0;
  90.       register BUCKET_CONTENTS *item_list;
  91.  
  92.       while (bucket < hashed_filenames->nbuckets)
  93.     {
  94.       item_list = get_hash_bucket (bucket, hashed_filenames);
  95.       if (item_list)
  96.         {
  97.           if (!any_printed)
  98.         {
  99.           printf ("hits\tcommand\n");
  100.           any_printed++;
  101.         }
  102.           while (item_list)
  103.         {
  104.           printf ("%4d\t%s\n",
  105.               item_list->times_found, pathdata(item_list)->path);
  106.           item_list = item_list->next;
  107.         }
  108.         }
  109.       bucket++;
  110.     }
  111.       if (!any_printed)
  112.     printf ("No commands in hash table.\n");
  113.  
  114.       return (EXECUTION_SUCCESS);
  115.     }
  116.  
  117.   if (expunge_hash_table)
  118.     {
  119.       int bucket = 0;
  120.       register BUCKET_CONTENTS *item_list, *prev;
  121.  
  122.       while (bucket < hashed_filenames->nbuckets)
  123.     {
  124.       item_list = get_hash_bucket (bucket, hashed_filenames);
  125.       if (item_list)
  126.         {
  127.           while (item_list)
  128.         {
  129.           prev = item_list;
  130.           free (item_list->key);
  131.           free (pathdata(item_list)->path);
  132.           free (item_list->data);
  133.           item_list = item_list->next;
  134.           free (prev);
  135.         }
  136.           hashed_filenames->bucket_array[bucket] = (BUCKET_CONTENTS *)NULL;
  137.         }
  138.       bucket++;
  139.     }
  140.     }
  141.  
  142.   while (list)
  143.     {
  144.       /* Add or rehash the specified commands. */
  145.       extern Function *find_shell_builtin ();
  146.       extern char *find_user_command ();
  147.       char *word;
  148.       char *full_path;
  149.       SHELL_VAR *var;
  150.  
  151.       word = list->word->word;
  152.       if (absolute_program (word))
  153.     {
  154.       list = list->next;
  155.       continue;
  156.     }
  157.       full_path = find_user_command (word);
  158.       var = find_function (word);
  159.  
  160.       if (!find_shell_builtin (word) && (!var))
  161.     {
  162.       if (full_path && executable_file (full_path))
  163.         {
  164.           extern int dot_found_in_search;
  165.           remember_filename (word, full_path, dot_found_in_search);
  166.         }
  167.       else
  168.         {
  169.           builtin_error ("%s: not found", word);
  170.           any_failed++;
  171.         }
  172.     }
  173.       list = list->next;
  174.     }
  175.  
  176.   fflush (stdout);
  177.  
  178.   if (any_failed)
  179.     return (EXECUTION_FAILURE);
  180.   else
  181.     return (EXECUTION_SUCCESS);
  182. }
  183.  
  184. /* Place FILENAME (key) and FULL_PATHNAME (data->path) into the
  185.    hash table.  CHECK_DOT if non-null is for future calls to
  186.    find_hashed_filename (). */
  187. void
  188. remember_filename (filename, full_pathname, check_dot)
  189.      char *filename, *full_pathname;
  190.      int check_dot;
  191. {
  192.   register BUCKET_CONTENTS *item;
  193.  
  194.   if (hashing_disabled)
  195.     return;
  196.   item = add_hash_item (filename, hashed_filenames);
  197.   if (item->data)
  198.     free (pathdata(item)->path);
  199.   else
  200.     item->data = (char *)xmalloc (sizeof (PATH_DATA));
  201.  
  202.   item->key = savestring (filename);
  203.   pathdata(item)->path = savestring (full_pathname);
  204.   pathdata(item)->check_dot = check_dot;
  205.   item->times_found = 0;
  206. }
  207.  
  208.